package controller

import (
	"net/http"
	"strconv"

	"github.com/example/video_backend/internal/model"
	"github.com/example/video_backend/internal/service"
	"github.com/example/video_backend/pkg/jwt"
	"github.com/example/video_backend/pkg/logger"
	"github.com/gin-gonic/gin"
)

// AdminController 管理员控制器
type AdminController struct {
	adminService service.AdminService
}

// NewAdminController 创建管理员控制器实例
func NewAdminController(
	adminService service.AdminService,
) *AdminController {
	return &AdminController{
		adminService: adminService,
	}
}

// AdminLogin 管理员登录
type AdminLoginRequest struct {
	Username string `json:"username" binding:"required"`
	Password string `json:"password" binding:"required"`
}

type AdminLoginResponse struct {
	Token string      `json:"token"`
	User  *model.User `json:"user"`
}

// @Summary 管理员登录
// @Description 管理员账号登录
// @Tags 管理员
// @Accept json
// @Produce json
// @Param request body AdminLoginRequest true "登录请求参数"
// @Success 200 {object} Response{data=AdminLoginResponse}
// @Router /api/v1/admin/login [post]
func (c *AdminController) AdminLogin(ctx *gin.Context) {
	var req AdminLoginRequest
	if err := ctx.ShouldBindJSON(&req); err != nil {
		logger.Error("Admin login request binding error: " + err.Error())
		ctx.JSON(http.StatusBadRequest, Response{Code: 400, Message: err.Error()})
		return
	}

	// 验证用户是否存在且是管理员
	user, err := c.adminService.Login(ctx, req.Username, req.Password)
	if err != nil {
		logger.Error("Admin login error: " + err.Error())
		ctx.JSON(http.StatusUnauthorized, Response{Code: 401, Message: err.Error()})
		return
	}

	// 生成JWT token
	token, err := jwt.GenerateToken(user.ID, user.Username, user.IsAdmin)
	if err != nil {
		logger.Error("Generate token error: " + err.Error())
		ctx.JSON(http.StatusInternalServerError, Response{Code: 500, Message: "生成token失败"})
		return
	}

	response := AdminLoginResponse{
		Token: token,
		User:  user,
	}

	ctx.JSON(http.StatusOK, Response{Code: 200, Message: "登录成功", Data: response})
}

// GetUsers 获取用户列表
// @Summary 获取用户列表
// @Description 获取所有用户列表，支持分页
// @Tags 管理员-用户管理
// @Accept json
// @Produce json
// @Security Bearer
// @Param page query int false "页码，默认1"
// @Param page_size query int false "每页数量，默认10，最大100"
// @Success 200 {object} Response{data=map[string]interface{}}
// @Router /api/v1/admin/users [get]
func (c *AdminController) GetUsers(ctx *gin.Context) {
	// 检查是否是管理员
	isAdmin, exists := ctx.Get("isAdmin")
	if !exists || !isAdmin.(bool) {
		ctx.JSON(http.StatusForbidden, Response{Code: 403, Message: "无管理员权限"})
		return
	}

	page, _ := strconv.Atoi(ctx.DefaultQuery("page", "1"))
	pageSize, _ := strconv.Atoi(ctx.DefaultQuery("page_size", "10"))

	// 限制每页数量
	if pageSize > 100 {
		pageSize = 100
	}

	users, total, err := c.adminService.ListUsers(ctx, page, pageSize)
	if err != nil {
		logger.Error("Get users error: " + err.Error())
		ctx.JSON(http.StatusInternalServerError, Response{Code: 500, Message: "获取用户列表失败"})
		return
	}

	ctx.JSON(http.StatusOK, Response{Code: 200, Message: "获取成功", Data: map[string]interface{}{
		"users":    users,
		"total":    total,
		"page":     page,
		"page_size": pageSize,
	}})
}

// UpdateUserStatus 更新用户状态
// @Summary 更新用户状态
// @Description 启用或禁用用户账号
// @Tags 管理员-用户管理
// @Accept json
// @Produce json
// @Security Bearer
// @Param id path int true "用户ID"
// @Param status query int true "状态码"
// @Success 200 {object} Response
// @Router /api/v1/admin/users/{id}/status [put]
func (c *AdminController) UpdateUserStatus(ctx *gin.Context) {
	// 检查是否是管理员
	isAdmin, exists := ctx.Get("isAdmin")
	if !exists || !isAdmin.(bool) {
		ctx.JSON(http.StatusForbidden, Response{Code: 403, Message: "无管理员权限"})
		return
	}

	userID, err := strconv.ParseUint(ctx.Param("id"), 10, 64)
	if err != nil {
		ctx.JSON(http.StatusBadRequest, Response{Code: 400, Message: "无效的用户ID"})
		return
	}

	status, err := strconv.Atoi(ctx.Query("status"))
	if err != nil {
		ctx.JSON(http.StatusBadRequest, Response{Code: 400, Message: "status参数无效"})
		return
	}

	if err := c.adminService.UpdateUserStatus(ctx, uint(userID), status); err != nil {
		logger.Error("Update user status error: " + err.Error())
		ctx.JSON(http.StatusInternalServerError, Response{Code: 500, Message: err.Error()})
		return
	}

	ctx.JSON(http.StatusOK, Response{Code: 200, Message: "更新成功"})
}

// DeleteUser 删除用户
// @Summary 删除用户
// @Description 删除用户账号
// @Tags 管理员-用户管理
// @Accept json
// @Produce json
// @Security Bearer
// @Param id path int true "用户ID"
// @Success 200 {object} Response
// @Router /api/v1/admin/users/{id} [delete]
func (c *AdminController) DeleteUser(ctx *gin.Context) {
	// 检查是否是管理员
	isAdmin, exists := ctx.Get("isAdmin")
	if !exists || !isAdmin.(bool) {
		ctx.JSON(http.StatusForbidden, Response{Code: 403, Message: "无管理员权限"})
		return
	}

	userID, err := strconv.ParseUint(ctx.Param("id"), 10, 64)
	if err != nil {
		ctx.JSON(http.StatusBadRequest, Response{Code: 400, Message: "无效的用户ID"})
		return
	}

	if err := c.adminService.DeleteUser(ctx, uint(userID)); err != nil {
		logger.Error("Delete user error: " + err.Error())
		ctx.JSON(http.StatusInternalServerError, Response{Code: 500, Message: err.Error()})
		return
	}

	ctx.JSON(http.StatusOK, Response{Code: 200, Message: "删除成功"})
}

// GetVideos 获取视频列表
// @Summary 获取视频列表
// @Description 获取所有视频列表，支持分页和筛选
// @Tags 管理员-视频管理
// @Accept json
// @Produce json
// @Security Bearer
// @Param page query int false "页码，默认1"
// @Param page_size query int false "每页数量，默认10，最大100"
// @Param is_public query bool false "是否公开"
// @Param category_id query int false "分类ID"
// @Success 200 {object} Response{data=map[string]interface{}}
// @Router /api/v1/admin/videos [get]
func (c *AdminController) GetVideos(ctx *gin.Context) {
	// 检查是否是管理员
	isAdmin, exists := ctx.Get("isAdmin")
	if !exists || !isAdmin.(bool) {
		ctx.JSON(http.StatusForbidden, Response{Code: 403, Message: "无管理员权限"})
		return
	}

	page, _ := strconv.Atoi(ctx.DefaultQuery("page", "1"))
	pageSize, _ := strconv.Atoi(ctx.DefaultQuery("page_size", "10"))
	
	// 限制每页数量
	if pageSize > 100 {
		pageSize = 100
	}

	// 获取筛选条件
	isPublic := ctx.Query("is_public")
	categoryIDStr := ctx.Query("category_id")

	// 构建查询参数
	params := map[string]interface{}{}
	if isPublic != "" {
		isPublicBool, _ := strconv.ParseBool(isPublic)
		params["is_public"] = isPublicBool
	}
	if categoryIDStr != "" {
		categoryID, _ := strconv.ParseUint(categoryIDStr, 10, 64)
		params["category_id"] = categoryID
	}

	// 调用服务获取视频列表
	videos, total, err := c.adminService.ListVideos(ctx, page, pageSize, params)
	if err != nil {
		logger.Error("Get videos error: " + err.Error())
		ctx.JSON(http.StatusInternalServerError, Response{Code: 500, Message: "获取视频列表失败"})
		return
	}

	ctx.JSON(http.StatusOK, Response{Code: 200, Message: "获取成功", Data: map[string]interface{}{
		"videos":   videos,
		"total":    total,
		"page":     page,
		"page_size": pageSize,
	}})
}

// DeleteVideo 删除视频
// @Summary 删除视频
// @Description 删除视频
// @Tags 管理员-视频管理
// @Accept json
// @Produce json
// @Security Bearer
// @Param id path int true "视频ID"
// @Success 200 {object} Response
// @Router /api/v1/admin/videos/{id} [delete]
func (c *AdminController) DeleteVideo(ctx *gin.Context) {
	// 检查是否是管理员
	isAdmin, exists := ctx.Get("isAdmin")
	if !exists || !isAdmin.(bool) {
		ctx.JSON(http.StatusForbidden, Response{Code: 403, Message: "无管理员权限"})
		return
	}

	videoID, err := strconv.ParseUint(ctx.Param("id"), 10, 64)
	if err != nil {
		ctx.JSON(http.StatusBadRequest, Response{Code: 400, Message: "无效的视频ID"})
		return
	}

	if err := c.adminService.DeleteVideo(ctx, uint(videoID)); err != nil {
		logger.Error("Delete video error: " + err.Error())
		ctx.JSON(http.StatusInternalServerError, Response{Code: 500, Message: err.Error()})
		return
	}

	ctx.JSON(http.StatusOK, Response{Code: 200, Message: "删除成功"})
}

// UpdateVideoStatus 更新视频状态
// @Summary 更新视频状态
// @Description 启用或禁用视频
// @Tags 管理员-视频管理
// @Accept json
// @Produce json
// @Security Bearer
// @Param id path int true "视频ID"
// @Param is_public query bool true "是否公开"
// @Success 200 {object} Response
// @Router /api/v1/admin/videos/{id}/status [put]
func (c *AdminController) UpdateVideoStatus(ctx *gin.Context) {
	// 检查是否是管理员
	isAdmin, exists := ctx.Get("isAdmin")
	if !exists || !isAdmin.(bool) {
		ctx.JSON(http.StatusForbidden, Response{Code: 403, Message: "无管理员权限"})
		return
	}

	videoID, err := strconv.ParseUint(ctx.Param("id"), 10, 64)
	if err != nil {
		ctx.JSON(http.StatusBadRequest, Response{Code: 400, Message: "无效的视频ID"})
		return
	}

	isPublic, err := strconv.ParseBool(ctx.Query("is_public"))
	if err != nil {
		ctx.JSON(http.StatusBadRequest, Response{Code: 400, Message: "is_public参数无效"})
		return
	}

	if err := c.adminService.UpdateVideoStatus(ctx, uint(videoID), isPublic); err != nil {
		logger.Error("Update video status error: " + err.Error())
		ctx.JSON(http.StatusInternalServerError, Response{Code: 500, Message: err.Error()})
		return
	}

	ctx.JSON(http.StatusOK, Response{Code: 200, Message: "更新成功"})
}

// GetComments 获取评论列表
// @Summary 获取评论列表
// @Description 获取所有评论列表，支持分页和筛选
// @Tags 管理员-评论管理
// @Accept json
// @Produce json
// @Security Bearer
// @Param page query int false "页码，默认1"
// @Param page_size query int false "每页数量，默认10，最大100"
// @Param video_id query int false "视频ID"
// @Param user_id query int false "用户ID"
// @Success 200 {object} Response{data=map[string]interface{}}
// @Router /api/v1/admin/comments [get]
func (c *AdminController) GetComments(ctx *gin.Context) {
	// 检查是否是管理员
	isAdmin, exists := ctx.Get("isAdmin")
	if !exists || !isAdmin.(bool) {
		ctx.JSON(http.StatusForbidden, Response{Code: 403, Message: "无管理员权限"})
		return
	}

	page, _ := strconv.Atoi(ctx.DefaultQuery("page", "1"))
	pageSize, _ := strconv.Atoi(ctx.DefaultQuery("page_size", "10"))
	
	// 限制每页数量
	if pageSize > 100 {
		pageSize = 100
	}

	// 获取筛选条件
	videoIDStr := ctx.Query("video_id")
	userIDStr := ctx.Query("user_id")

	// 构建查询参数
	params := map[string]interface{}{}
	if videoIDStr != "" {
		videoID, _ := strconv.ParseUint(videoIDStr, 10, 64)
		params["video_id"] = videoID
	}
	if userIDStr != "" {
		userID, _ := strconv.ParseUint(userIDStr, 10, 64)
		params["user_id"] = userID
	}

	// 调用服务获取评论列表
	comments, total, err := c.adminService.ListComments(ctx, page, pageSize, params)
	if err != nil {
		logger.Error("Get comments error: " + err.Error())
		ctx.JSON(http.StatusInternalServerError, Response{Code: 500, Message: "获取评论列表失败"})
		return
	}

	ctx.JSON(http.StatusOK, Response{Code: 200, Message: "获取成功", Data: map[string]interface{}{
		"comments": comments,
		"total":    total,
		"page":     page,
		"page_size": pageSize,
	}})
}

// DeleteComment 删除评论
// @Summary 删除评论
// @Description 删除评论
// @Tags 管理员-评论管理
// @Accept json
// @Produce json
// @Security Bearer
// @Param id path int true "评论ID"
// @Success 200 {object} Response
// @Router /api/v1/admin/comments/{id} [delete]
func (c *AdminController) DeleteComment(ctx *gin.Context) {
	// 检查是否是管理员
	isAdmin, exists := ctx.Get("isAdmin")
	if !exists || !isAdmin.(bool) {
		ctx.JSON(http.StatusForbidden, Response{Code: 403, Message: "无管理员权限"})
		return
	}

	commentID, err := strconv.ParseUint(ctx.Param("id"), 10, 64)
	if err != nil {
		ctx.JSON(http.StatusBadRequest, Response{Code: 400, Message: "无效的评论ID"})
		return
	}

	if err := c.adminService.DeleteComment(ctx, uint(commentID)); err != nil {
		logger.Error("Delete comment error: " + err.Error())
		ctx.JSON(http.StatusInternalServerError, Response{Code: 500, Message: err.Error()})
		return
	}

	ctx.JSON(http.StatusOK, Response{Code: 200, Message: "删除成功"})
}